import { isArray } from '@/utils/is';
import { AuthStore } from '@/stores/modules/auth';

/**
 * @description 获取localStorage
 * @param {String} key Storage名称
 * @return string
 */
export function localGet(key: string) {
	const value = window.localStorage.getItem(key);
	try {
		return JSON.parse(window.localStorage.getItem(key) as string);
	} catch (error) {
		return value;
	}
}

/**
 * @description 存储localStorage
 * @param {String} key Storage名称
 * @param {Any} value Storage值
 * @return void
 */
export function localSet(key: string, value: any) {
	window.localStorage.setItem(key, JSON.stringify(value));
}

/**
 * @description 清除localStorage
 * @param {String} key Storage名称
 * @return void
 */
export function localRemove(key: string) {
	window.localStorage.removeItem(key);
}

/**
 * @description 清除所有localStorage
 * @return void
 */
export function localClear() {
	window.localStorage.clear();
}

/**
 * @description 判断数据类型
 * @param {Any} val 需要判断类型的数据
 * @return string
 */
export function isType(val: any) {
	if (val === null) return 'null';
	if (typeof val !== 'object') return typeof val;
	else return Object.prototype.toString.call(val).slice(8, -1).toLocaleLowerCase();
}

/**
 * @description 生成唯一 uuid
 * @return string
 */
export function generateUUID() {
	if (typeof crypto === 'object') {
		if (typeof crypto.randomUUID === 'function') {
			return crypto.randomUUID();
		}
		if (typeof crypto.getRandomValues === 'function' && typeof Uint8Array === 'function') {
			const callback = (c: any) => {
				const num = Number(c);
				return (num ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (num / 4)))).toString(16);
			};
			return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, callback);
		}
	}
	let timestamp = new Date().getTime();
	let performanceNow = (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0;
	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
		let random = Math.random() * 16;
		if (timestamp > 0) {
			random = (timestamp + random) % 16 | 0;
			timestamp = Math.floor(timestamp / 16);
		} else {
			random = (performanceNow + random) % 16 | 0;
			performanceNow = Math.floor(performanceNow / 16);
		}
		return (c === 'x' ? random : (random & 0x3) | 0x8).toString(16);
	});
}

/**
 * 判断两个对象是否相同
 * @param a 要比较的对象一
 * @param b 要比较的对象二
 * @returns 相同返回 true，反之则反
 */
export function isObjectValueEqual(a: { [key: string]: any }, b: { [key: string]: any }) {
	if (!a || !b) return false;
	const aProps = Object.getOwnPropertyNames(a);
	const bProps = Object.getOwnPropertyNames(b);
	if (aProps.length != bProps.length) return false;
	for (let i = 0; i < aProps.length; i++) {
		const propName = aProps[i];
		const propA = a[propName];
		const propB = b[propName];
		if (!b.hasOwnProperty(propName)) return false;
		if (propA instanceof Object) {
			if (!isObjectValueEqual(propA, propB)) return false;
		} else if (propA !== propB) {
			return false;
		}
	}
	return true;
}

/**
 * @description 生成随机数
 * @param {Number} min 最小值
 * @param {Number} max 最大值
 * @return number
 */
export function randomNum(min: number, max: number): number {
	const num = Math.floor(Math.random() * (min - max) + max);
	return num;
}

/**
 * @description 获取当前时间对应的提示语
 * @return string
 */
export function getTimeState() {
	// 获取当前时间
	const timeNow = new Date();
	// 获取当前小时
	const hours = timeNow.getHours();
	// 判断当前时间段
	if (hours >= 6 && hours <= 10) return `早上好 ⛅`;
	if (hours >= 10 && hours <= 14) return `中午好 🌞`;
	if (hours >= 14 && hours <= 18) return `下午好 🌞`;
	if (hours >= 18 && hours <= 24) return `晚上好 🌛`;
	if (hours >= 0 && hours <= 6) return `凌晨好 🌛`;
}

/**
 * @description 获取浏览器默认语言
 * @return string
 */
export function getBrowserLang() {
	const browserLang = navigator.language ? navigator.language : navigator.browserLanguage;
	let defaultBrowserLang = '';
	if (browserLang.toLowerCase() === 'cn' || browserLang.toLowerCase() === 'zh' || browserLang.toLowerCase() === 'zh-cn') {
		defaultBrowserLang = 'zh';
	} else {
		defaultBrowserLang = 'en';
	}
	return defaultBrowserLang;
}

/**
 * @description 递归查询当前路由所对应的路由
 * @param {Array} menuList 所有菜单列表
 * @param {String} path 当前访问地址
 * @return array
 */
export function filterCurrentRoute(menuList: Menu.MenuOptions[], path: string) {
	let result = {};
	for (const item of menuList) {
		if (item.path === path) return item;
		if (item.children) {
			const res = filterCurrentRoute(item.children, path);
			if (Object.keys(res).length) result = res;
		}
	}
	return result;
}

/**
 * 递归方式构建菜单树
 * @param {Array} list 所有菜单项
 * @param {Number} parentId 父菜单ID
 * @returns {Array} 树形菜单
 */
export function buildMenuTreeRecursive<T = any>(list: any[], parentId = 0) {
	const tree: T[] = [];
	list
		.filter(menu => menu.parentId === parentId)
		.sort((a, b) => a.orderNum - b.orderNum || a.menuId - b.menuId)
		.forEach(menu => {
			const children = buildMenuTreeRecursive(list, menu.menuId);
			if (children.length > 0) {
				menu.children = children;
			}
			tree.push(menu);
		});

	return tree;
}

/**
 * @description 扁平化数组对象(主要用来处理路由菜单)
 * @param {Array} menuList 所有菜单列表
 * @return array
 */
export function getFlatArr(menuList: Menu.MenuOptions[], childrenType: string = 'children'): any[] {
	const newMenuList: Menu.MenuOptions[] = JSON.parse(JSON.stringify(menuList));
	return newMenuList.reduce((pre: Menu.MenuOptions[], current: Menu.MenuOptions) => {
		let flatArr = [...pre, current];
		if (current[childrenType as keyof Menu.MenuOptions]) {
			flatArr = [...flatArr, ...getFlatArr(current[childrenType as keyof Menu.MenuOptions] as Menu.MenuOptions[], childrenType)];
		}
		return flatArr;
	}, [] as Menu.MenuOptions[]);
}

/**
 * 将行政区划数据转换为三级联动结构
 * @param data 原始数据数组
 * @param level 级别
 * @returns 树形结构数据
 */
export function transformToTreeData(data: any[], level: number = 3) {
	// 创建结果对象
	const result: any[] = [];

	// 先筛选出第一级（省级）
	const level1 = data.filter(item => item.admdvsLv === '1');

	level1.forEach(province => {
		const provinceNode: any = {
			value: province.admdvs,
			label: province.admdvsName,
			children: []
		};

		if (level >= 2) {
			// 筛选出属于当前省的市级数据
			const level2 = data.filter(item => item.admdvsLv === '2' && item.prntAdmdvs === province.admdvs);

			level2.forEach(city => {
				const cityNode: any = {
					value: city.admdvs,
					label: city.admdvsName,
					children: []
				};

				if (level >= 3) {
					// 筛选出属于当前市的区县级数据
					const level3 = data.filter(item => item.admdvsLv === '3' && item.prntAdmdvs === city.admdvs);

					cityNode.children = level3.map(county => ({
						value: county.admdvs,
						label: county.admdvsName
					}));
				}

				provinceNode.children.push(cityNode);
			});
		}

		result.push(provinceNode);
	});

	return result;
}

/**
 * @description 使用递归，过滤需要缓存的路由
 * @param {Array} menuList 所有菜单列表
 * @param {Array} cacheArr 缓存的路由菜单 name ['**','**']
 * @return array
 * */
export function getKeepAliveRouterName(menuList: Menu.MenuOptions[], keepAliveArr: string[] = []) {
	menuList.forEach(item => {
		item.meta.isKeepAlive && item.name && keepAliveArr.push(item.name);
		item.children?.length && getKeepAliveRouterName(item.children, keepAliveArr);
	});

	return keepAliveArr;
}

/**
 * @description 使用递归，过滤出需要渲染在左侧菜单的列表（剔除 isHide == true 的菜单）
 * @param {Array} menuList 所有菜单列表
 * @return array
 * */
export function getShowMenuList(menuList: Menu.MenuOptions[]) {
	const newMenuList: Menu.MenuOptions[] = JSON.parse(JSON.stringify(menuList));
	return newMenuList.filter(item => {
		item.children?.length && (item.children = getShowMenuList(item.children));
		return !item.meta?.isHide;
	});
}

/**
 * 递归转换菜单列表
 * @param { Array } menuList 原生菜单
 * @param { string } type 菜单中子菜单目录的字段名
 * @returns array
 */
export function getMenuLists(menuList: Menu.MenuOptions[], type: string = 'list'): any {
	const data: any = menuList.map((item: any) => {
		const path = item.url ? `/${item.url}` : '/home/index';
		return {
			name: getName(item.path ?? item.url),
			path,
			perms: path,
			menuId: item.menuId,
			component: path,
			meta: {
				icon: item?.icon ? deleteTrim(item?.icon) : '',
				title: item.name ?? item.title,
				menuId: item.menuId,
				parentId: item.parentId,
				sysId: item.sysId,
				isFull: false,
				isHide: item.meta?.isHide ?? false,
				isAffix: item.meta?.isAffix || false,
				isKeepAlive: !['/his/classificationRetrieval'].includes(item.perms)
			},
			children: item[type] ? getMenuLists(item[type]) : null
		};
	});
	return data;
}

/**
 * 获取 url中的
 * @param name
 * @returns
 */
export function getName(name: string): string {
	if (!name) {
		return '';
	}
	let nameArr: any = [];
	nameArr = name.split('/');
	const resultName = nameArr?.[nameArr.length - 1];
	return resultName;
}

/**
 * @description 使用递归处理路由菜单 path，生成一维数组(第一版本地路由鉴权会用到)
 * @param {Array} menuList 所有菜单列表
 * @param {Array} menuPathArr 菜单地址的一维数组 ['**','**']
 * @return array
 */
export function getMenuListPath(menuList: Menu.MenuOptions[], menuPathArr: string[] = []) {
	menuList.forEach((item: Menu.MenuOptions) => {
		typeof item === 'object' && item.path && menuPathArr.push(item.path);
		item.children?.length && getMenuListPath(item.children, menuPathArr);
	});
	return menuPathArr;
}

/**
 * @description 使用递归，过滤出当前路径匹配的面包屑地址
 * @param {String} path 当前访问地址
 * @param {Array} menuList 所有菜单列表
 * @returns array
 */
export function getCurrentBreadcrumb(path: string, menuList: Menu.MenuOptions[]) {
	const tempPath: Menu.MenuOptions[] = [];
	try {
		const getNodePath = (node: Menu.MenuOptions) => {
			tempPath.push(node);
			if (node.path === path) throw new Error('Find IT!');
			if (node.children?.length) node.children.forEach(item => getNodePath(item));
			tempPath.pop();
		};
		menuList.forEach(item => getNodePath(item));
	} catch (e) {
		return tempPath;
	}
}

/**
 * @description 双重递归找出所有面包屑存储到 pinia/vuex 中
 * @param {Array} menuList 所有菜单列表
 * @returns array
 */
export function getAllBreadcrumbList(menuList: Menu.MenuOptions[]) {
	const handleBreadcrumbList: { [key: string]: any } = {};
	const loop = (menuItem: Menu.MenuOptions) => {
		if (menuItem?.children?.length) menuItem.children.forEach(item => loop(item));
		handleBreadcrumbList[menuItem.path] = getCurrentBreadcrumb(menuItem.path, menuList);
	};
	menuList.forEach(item => loop(item));
	return handleBreadcrumbList;
}

/**
 * @description 格式化表格单元格默认值(el-table-column)
 * @param {Number} row 行
 * @param {Number} col 列
 * @param {String} callValue 当前单元格值
 * @return string
 * */
export function defaultFormat(row: number, col: number, callValue: any) {
	// 如果当前值为数组,使用 / 拼接（根据需求自定义）
	if (isArray(callValue)) return callValue.length ? callValue.join(' / ') : '--';
	return callValue ?? '--';
}

/**
 * @description 处理无数据情况
 * @param {String} callValue 需要处理的值
 * @return string
 * */
export function formatValue(callValue: any) {
	// 如果当前值为数组,使用 / 拼接（根据需求自定义）
	if (isArray(callValue)) return callValue.length ? callValue.join(' / ') : '--';
	return callValue === '' || callValue === null || callValue === undefined ? '--' : callValue;
}

/**
 * @description 处理 prop 为多级嵌套的情况(列如: prop:user.name)
 * @param {Object} row 当前行数据
 * @param {String} prop 当前 prop
 * @return any
 * */
export function handleRowAccordingToProp(row: { [key: string]: any }, prop: string) {
	if (!prop.includes('.')) return row[prop];
	prop.split('.').forEach((item: any) => {
		row = row[item] ?? '--';
	});
	return row;
}

/**
 * @description 处理 prop，当 prop 为多级嵌套时 ==> 返回最后一级 prop
 * @param {String} prop 当前 prop
 * @return string
 * */
export function handleProp(prop: string) {
	const propArr = prop.split('.');
	if (propArr.length == 1) return prop;
	return propArr[propArr.length - 1];
}

/**
 * @description 根据枚举列表查询当需要的数据（如果指定了 label 和 value 的 key值，会自动识别格式化）
 * @param {String} callValue 当前单元格值
 * @param {Array} enumData 枚举列表
 * @param {String} type 过滤类型（目前只有 tag）
 * @return string
 * */
export function filterEnum(
	callValue: any,
	enumData: { [key: string]: any } | undefined,
	searchProps?: { [key: string]: any },
	type?: string
): string {
	const value = searchProps?.value ?? 'value';
	const label = searchProps?.label ?? 'label';
	let filterData: any = {};
	if (Array.isArray(enumData)) filterData = enumData.find((item: any) => item[value] === callValue);
	if (type == 'tag') return filterData?.tagType ? filterData.tagType : '';
	return filterData ? filterData[label] : '--';
}
export const getCookie = (name: string) => document.cookie.match(`[;\s+]?${name}=([^;]*)`)?.pop();

/**
 * 去空格
 * @param str
 * @returns
 */
export function deleteTrim(str: string): string {
	const s = str.replace(/\s*/g, '');
	// console.log(str.replace(/\- || s*/g, ""));
	return s.replace(/\-/g, '');
}

/**
 * 将一维数组变成多维数组
 * @param {Array} data 传过来的一维数组
 * @param {number | string} fisrtId 第一层id值 默认-1
 * @param {string} fatherId 父层级关键字段 默认menuId
 * @param {string} childId 子层级关键字段 默认parentId
 * @returns {Array}
 */
export function getMultistage(
	data: any[],
	fisrtId: number | string = -1,
	fatherId: string = 'menuId',
	childId: string = 'parentId'
): any[] {
	const cloneData = JSON.parse(JSON.stringify(data)); // 对源数据深度克隆
	return cloneData.filter((father: any) => {
		const branchArr = cloneData.filter((child: any) => father[fatherId] == child[childId]); //返回每一项的子级数组
		branchArr.length > 0 ? (father.children = branchArr) : ''; //如果存在子级，则给父级添加一个children属性，并赋值
		return father.parentId == fisrtId; //返回第一层
	});
}

/**
 * 水印
 * @returns Function
 */
export const getmark = (): any => {
	const setWatermark = (str: any) => {
		const id = '1.23452384164.123412416';

		if (document.getElementById(id) !== null) {
			document.body.removeChild(document.getElementById(id)!);
		}

		//创建一个画布
		const can = document.createElement('canvas');
		//设置画布的长宽
		can.width = 150;
		can.height = 120;

		const cans = can.getContext('2d')!;
		//旋转角度
		cans.rotate((-15 * Math.PI) / 180);
		cans.font = '18px Vedana';
		//设置填充绘画的颜色、渐变或者模式
		cans.fillStyle = 'rgba(200, 200, 200, 0.40)';
		//设置文本内容的当前对齐方式
		cans.textAlign = 'left';
		//设置在绘制文本时使用的当前文本基线
		// cans.textBaseline = "Middle";
		//在画布上绘制填色的文本（输出的文本，开始绘制文本的X坐标位置，开始绘制文本的Y坐标位置）
		cans.fillText(str, can.width / 8, can.height / 2);

		const div = document.createElement('div');
		div.id = id;
		div.style.pointerEvents = 'none';
		div.style.top = '30px';
		div.style.left = '0px';
		div.style.position = 'fixed';
		div.style.zIndex = '100000';
		div.style.width = document.documentElement.clientWidth + 'px';
		div.style.height = document.documentElement.clientHeight + 'px';
		div.style.background = 'url(' + can.toDataURL('image/png') + ') left top repeat';
		document.body.appendChild(div);
		return id;
	};

	// 该方法只允许调用一次
	const watermark = (str: string) => {
		let id = setWatermark(str);
		setInterval(() => {
			if (document.getElementById(id) === null) {
				id = setWatermark(str);
			}
		}, 500);
		window.onresize = () => {
			setWatermark(str);
		};
	};
	return { watermark };
};

/**
 * 拼接两定机构识别设备联动数据
 * @param getDevOpslist
 * @param getDeptlist
 * @param selectOrgDept
 * @param userInfo
 * @returns
 */
export const getCascaderList = async (getDevOpslist: any, getDeptlist: any, selectOrgDept: string[], userInfo: any) => {
	let options: any = [];
	const selectDept = selectOrgDept;
	const devList: any = await getDevOpslist({ pageNum: 1, pageSize: 1000 }, { medinsCode: userInfo.value?.orgCodg });
	const filterDept = devList?.data?.data?.filter((item: any) => {
		return item.deptId;
	});
	// console.log(devList?.data.data, filterDept);
	const deptList = await getDeptlist({ pageNum: 1, pageSize: 1000 });

	const deptAll: any = deptList.data;

	const filterDepts = deptAll?.map((item: any) => {
		return item.deptId;
	});

	const filterD = filterDepts?.filter((item1: any) => selectDept.includes(item1));
	let deptArr: any = [];

	const dataArr = deptAll?.filter((item1: any) => filterD.includes(item1.deptId));

	if (filterD.length > 0) {
		deptArr = dataArr.map((item: any) => {
			return {
				value: item.deptId,
				label: item.deptName,
				children: []
			};
		});
	} else {
		deptArr = deptAll.map((item: any) => {
			return {
				value: item.deptId,
				label: item.deptName,
				children: []
			};
		});
	}

	// 机构有科室的时候
	if (deptArr.length > 0) {
		options = deptArr.map((item: any) => {
			for (let i = 0; i < filterDept.length; i++) {
				if (filterDept[i].deptId.indexOf(item.value) !== -1) {
					const obj = {
						label: filterDept[i].devName,
						value: filterDept[i].devCode
					};
					item.children.push(obj);
				}
			}
			return item;
		});
	} else {
		const filterDept2 = devList.data.filter((item: any) => {
			return item.medinsCode;
		});
		const medinsArr = [{ value: userInfo.value.orgCodg, label: userInfo.value.orgName, children: [] }];
		options = medinsArr.map((item: any) => {
			for (let i = 0; i < filterDept2.length; i++) {
				const obj = {
					label: filterDept2[i].devName,
					value: filterDept2[i].devCode
				};
				item.children.push(obj);
			}
			return item;
		});
	}

	return options;
};

/**
 * 重组系统参数
 * @param params
 * @returns
 */
export const getSysParams = (params: any): any => {
	if (params?.length > 0) {
		const sysObj: { [key: string]: any } = {};
		params.forEach((item: { paraName: string; paraValue: string | number }) => {
			sysObj[item.paraName] = item.paraValue;
		});
		return sysObj;
	}
	return {};
};

/**
 * 获取日期
 * @param dateType date不带时分秒 datetime带时分秒
 * @param time 日期
 * @param isHMS 是否只展示时分秒
 * @param isNextYear 是否明年
 * @param isYhSpace 日期后面的时分秒和日期是否有空格
 */
export const getDateTime = (
	dateType: string = 'date',
	time: Date = new Date(),
	isHMS: boolean = false,
	isNextYear: boolean = false,
	isYhSpace: boolean = false
): string => {
	const year = isNextYear ? new Date(time).getFullYear() + 1 : new Date(time).getFullYear();
	const month = new Date(time).getMonth() + 1 < 10 ? '0' + (new Date(time).getMonth() + 1) : new Date(time).getMonth() + 1;
	const date = new Date(time).getDate() < 10 ? '0' + new Date(time).getDate() : new Date(time).getDate();
	const hh = new Date(time).getHours() < 10 ? '0' + new Date(time).getHours() : new Date(time).getHours();
	const mm = new Date(time).getMinutes() < 10 ? '0' + new Date(time).getMinutes() : new Date(time).getMinutes();
	const ss = new Date(time).getSeconds() < 10 ? '0' + new Date(time).getSeconds() : new Date(time).getSeconds();
	if (dateType === 'date') {
		return `${year}-${month}-${date}`;
	} else {
		if (isHMS) {
			return `${hh}:${mm}:${ss}`;
		} else {
			return isYhSpace ? `${year}${month}${date} ${hh}${mm}${ss}` : `${year}${month}${date}${hh}${mm}${ss}`;
		}
	}
};

/**
 * 获取从当天算起天数的起始和结尾日期
 * @param dayNum 天数 默认30天
 * @param isBefore 是否包含当天
 * @returns
 */
export const getTimeInfo = (dayNum: number = 30, isBefore: boolean = true): string[] => {
	// 获取当前时间
	const timeArr: string[] = [];
	const myDate: any = new Date();
	// 获取三十天前日期
	const lw: Date = new Date(myDate - 1000 * 60 * 60 * 24 * dayNum); // 最后一个数字30可改，30天的意思
	const lastY: number = lw.getFullYear();
	const lastM: number = lw.getMonth() + 1;
	const lastD: number = lw.getDate();
	const startdate: string = lastY + '-' + (lastM < 10 ? '0' + lastM : lastM) + '-' + (lastD < 10 ? '0' + lastD : lastD); // 三十天之前日期
	timeArr.push(startdate);
	timeArr.push(!isBefore ? getDateTime('date') : getDateTime('date', new Date(myDate - 1000 * 60 * 60 * 24)));
	return timeArr;
};

/**
 * 往前推的月份时间
 * @param monthNum number 往前推的月份数
 * @param time Date 往前推的时间
 * @returns sting[]
 */
export const getMonthRange = (isTimestamp = true, monthNum = 12, time = new Date()): Array<string | number> => {
	// 创建一个副本，避免修改原始日期对象
	const tenMonthsAgo = new Date(time.getTime());

	// 月份是从0开始的，所以减去10个月
	tenMonthsAgo.setMonth(tenMonthsAgo.getMonth() - monthNum);
	let startDate: number | string = `${formatDate(tenMonthsAgo, 'yyyy-MM-dd hh:mm:ss')}`;
	let endDate: number | string = `${formatDate(time, 'yyyy-MM-dd hh:mm:ss')}`;
	if (isTimestamp) {
		startDate = new Date(startDate).getTime();
		endDate = new Date(endDate).getTime();
	}
	return [startDate, endDate];
};

/**
 * 密码加密
 * @param message 密码
 * @param key 获取的key
 * @returns
 */
export const decryptByDES = (message: string, key: any): any => {
	const CryptoJS: any = window?.CryptoJS;
	if (CryptoJS) {
		const keyHex: any = CryptoJS.enc.Utf8.parse(key);
		const m: any = CryptoJS.enc.Utf8.parse(message);
		const decrypted: any = CryptoJS.AES.encrypt(m, keyHex, {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		}).toString();
		const resultValue: any = decrypted.toString(CryptoJS.enc.Utf8);
		return resultValue;
	}
};

/**
 *
 * @param time
 * @param fmt
 * @returns
 */ /**
 * 根据指定的格式和时间戳格式化日期。
 * @param time 时间戳，可以是数字类型表示的秒数或毫秒数，或者是Date对象。
 * @param fmt 日期格式字符串，例如：'yyyy-MM-dd hh:mm:ss'。
 * @returns 格式化后的日期字符串，如果时间参数为空，则返回"--"。
 */
export function formatDate(time: any, fmt: string): string {
	// 如果时间参数为空，则直接返回"--"作为格式化结果
	if (!time) {
		return '--';
	}
	// 创建Date对象，以便进行日期格式化
	const date = new Date(time);

	// 处理年份的格式化，例如：将yyyy替换为四位数的年份
	if (/(y+)/.test(fmt)) {
		fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
	}

	// 定义一个对象，用于存储月份、日期、小时、分钟和秒的格式化值
	const o: any = {
		'M+': date.getMonth() + 1, // 月份，注意JavaScript中月份从0开始
		'd+': date.getDate(), // 日
		'h+': date.getHours(), // 小时，24小时制
		'm+': date.getMinutes(), // 分钟
		's+': date.getSeconds() // 秒
	};

	// 遍历o对象，将日期时间的各个部分按照fmt的格式插入到格式化字符串中
	for (const k in o) {
		// 如果fmt中包含当前遍历的日期时间部分的格式标识（如M+、d+等），则进行替换
		if (new RegExp(`(${k})`).test(fmt)) {
			// 将日期时间部分的值转换为字符串
			const str: any = o?.[k] + '';
			// 如果格式标识长度为1，直接替换；否则，通过padLeftZero函数在值前面补0，以保证两位数的格式
			fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? str : padLeftZero(str));
		}
	}
	// 返回最终格式化后的日期字符串
	return fmt;
}

/**
 * 在字符串的左侧补0，以达到指定的长度。
 * @param str 需要补0的字符串。
 * @param len 目标长度。
 * @returns 补齐0后的字符串。
 */
export function padLeftZero(str: string): string {
	return str.length < 2 ? '0' + str : str;
}

/**
 * 生成一个用于确认删除操作的警告消息
 *
 * 该函数主要用于在用户界面(UI)中显示一个警告消息，以确认用户是否真的想删除某条信息
 * 它接受一个可选参数`message`，用于指定要删除的信息内容，默认值为'内涵配置'
 *
 * @param message 要删除的信息内容，默认为'内涵配置'
 * @returns 返回一个包含删除确认消息的HTML字符串
 *
 * 之所以使用模板字符串和HTML标签，是为了在UI中直接显示格式化的确认消息，
 * 包括删除操作的后果和确认提示，以确保用户对将要进行的操作有清晰的认识
 */
export function deleteMessage(message = '内涵配置'): string {
	return `<div><p>您正在删除${message}信息，此${message}删除后，将无法恢复。</p><p style="color: rgba(247,122,0,1)">您确认要删除吗?</p></div>`;
}

// 失效
export const statusMessage = (message: string, type: number = 1): string => {
	let str = '';
	if (type === 1) {
		str = `<div><p>您正在失效${message}信息，此信息失效后，医院将无法调用。</p><p style="color: rgba(247,122,0,1)">您确认要失效吗?</p></div>`;
	} else if (type === 2) {
		str = `<div><p>生效后，支持医院调用。是否生效？</p></div>`;
	}
	return str;
};

/**
 * 数组去重, 数组中的值要完成一样才能去重
 * @param array
 * @returns any[]
 */
export function uniqueArray(array: any[]): any[] {
	const uniqueArray = Array.from(array.reduce((map, obj) => map.set(JSON.stringify(obj), obj), new Map()).values());
	return uniqueArray;
}

/**
 * 数组去重, 通过id来去重
 * @param array
 * @param id
 * @returns any[]
 */

export function uniqueFunc(arr: any[], id: string) {
	const mapArr = new Map();
	return arr.filter((item: any) => !mapArr.has(item[id]) && mapArr.set(item[id], 1));
}

/**
 * 获取uuid
 */
export function getUUID() {
	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
		const r = (Math.random() * 16) | 0;
		const v = c === 'x' ? r : (r & 0x3) | 0x8;
		return v.toString(16);
	});
}

/**
 * 判断是否已授权
 * @param key
 * @returns
 */
export function isAuth(key: string) {
	const authStore = AuthStore();
	return authStore.authButtonListGet.includes(key);
}
